home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / ghostscript / 8.64 / Resource / Init / gs_cff.ps < prev    next >
Encoding:
Text File  |  2009-04-17  |  24.0 KB  |  857 lines
  1. %    Copyright (C) 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_cff.ps 9351 2009-01-13 22:17:21Z alexcher $
  17. % Loader for CFF (compressed) fonts, including OpenType CFFs.
  18. % The following are not implemented yet:
  19. %    Deleted entries in the Name Index
  20. %    Embedded PostScript
  21. %    Multiple Master fonts
  22. %    Chameleon fonts
  23. %    Synthetic fonts
  24.  
  25. % ---------------- Font loading machinery ---------------- %
  26.  
  27. % Augment the FONTPATH machinery so it recognizes OpenType CFF font sets.
  28.  
  29. /.scanfontheaders where {
  30.   pop /.scanfontheaders [
  31.    .scanfontheaders aload pop (OTTO*)
  32.   ] def
  33. } if
  34.  
  35. % Load a font file that might be an OpenType CFF font set.
  36.  
  37. % <file> .loadfontfile -
  38. /.loadnonottofontfile /.loadfontfile load def
  39. /.loadfontfile {
  40.   dup 4 string .peekstring pop (OTTO) eq {
  41.         % If this is a font at all, it's an OpenType CFF font set.
  42.     .init_otto_font_file
  43.     % Use a random FontSet resource name.  ****** WRONG ******
  44.     realtime rand xor =string cvs exch //false //false
  45.     ReadData pop
  46.   } {
  47.         % Not a TrueType font.
  48.     .loadnonottofontfile
  49.   } ifelse
  50. } bind def
  51.  
  52. % <file> .init_otto_font_file <file>
  53. /.init_otto_font_file {
  54.   /FontSetInit /ProcSet findresource begin
  55.   2 dict begin
  56.   /f exch def /cff null def
  57.   card32 pop card16 6 { next pop } repeat dup {
  58.         % Stack: numtables tablesleft
  59.     dup 0 eq {
  60.       pop pop /.loadottofontfile cvx /invalidfont signalerror
  61.     } if
  62.     f 4 string readstring pop (CFF ) eq { sub exit } if
  63.     f 12 string readstring pop pop 1 sub    % skip to next table
  64.   } loop
  65.         % Stack: tablesread
  66.   card32 pop card32 card32
  67.         % Stack: tablesread start length
  68.   exch 3 -1 roll 1 add 16 mul 12 add sub
  69.   f exch subfilefilter flushfile    % skip to start
  70.   f exch subfilefilter end
  71. } bind def
  72.  
  73. 53 dict begin
  74.  
  75. % ---------------- Standard strings (actually names) ---------------- %
  76.  
  77. /StandardStrings mark
  78.     % The initial StandardStrings that that denote characters are
  79.     % defined as a pseudo-Encoding.
  80. % 0
  81.   /CFFStandardStrings .findencoding aload pop
  82. % 379
  83.   (001.000)
  84. % 380
  85.   (001.001) (001.002) (001.003) /Black /Bold
  86.   /Book /Light /Medium /Regular /Roman
  87.   /Semibold
  88. .packtomark def
  89.  
  90. % ---------------- Standard encodings ---------------- %
  91.  
  92. /StandardEncodings [
  93.  
  94. % StandardEncoding
  95. mark
  96.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  97.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  98.   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  99.   17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
  100.   33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
  101.   49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
  102.   65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
  103.   81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 0
  104.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  105.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  106.   0 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
  107.   0 111 112 113 114 0 115 116 117 118 119 120 121 122 0 123
  108.   0 124 125 126 127 128 129 130 131 0 132 133 0 134 135 136
  109.   137 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  110.   0 138 0 139 0 0 0 0 140 141 142 143 0 0 0 0
  111.   0 144 0 0 0 145 0 0 146 147 148 149 0 0 0 0
  112. .packtomark
  113.  
  114. % ExpertEncoding
  115. mark
  116.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  117.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  118.   1 229 230 0 231 232 233 234 235 236 237 238 13 14 15 99
  119.   239 240 241 242 243 244 245 246 247 248 27 28 249 250 251 252
  120.   0 253 254 255 256 257 0 0 0 258 0 0 259 260 261 262
  121.   0 0 263 264 265 0 266 109 110 267 268 269 0 270 271 272
  122.   273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
  123.   289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 0
  124.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  125.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  126.   0 304 305 306 0 0 307 308 309 310 311 0 312 0 0 313
  127.   0 0 314 315 0 0 316 317 318 0 0 0 158 155 163 319
  128.   320 321 322 323 324 325 0 0 326 150 164 169 327 328 329 330
  129.   331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
  130.   347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
  131.   363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
  132. .packtomark
  133.  
  134. ] readonly def
  135.  
  136. % ---------------- Standard Charsets ---------------- %
  137.  
  138. % We include an explicit 0 at the beginning of each charset.
  139.  
  140. /StandardCharsets [
  141.  
  142. % ISOAdobe
  143. mark
  144.   0
  145.   1 1 228 { } for
  146. .packtomark
  147.  
  148. % Expert
  149. mark
  150.   0
  151.   1 229 230 231 232 233 234 235 236 237 238 13 14 15 99 239
  152.   240 241 242 243 244 245 246 247 248 27 28 249 250 251 252 253
  153.   254 255 256 257 258 259 260 261 262 263 264 265 266 109 110 267
  154.   268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
  155.   284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
  156.   300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
  157.   316 317 318 158 155 163 319 320 321 322 323 324 325 326 150 164
  158.   169 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
  159.   342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
  160.   358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
  161.   374 375 376 377 378
  162. .packtomark
  163.  
  164. % ExpertSubset
  165. mark
  166.   0
  167.   1 231 232 235 236 237 238 13 14 15 99 239 240 241 242 243
  168.   244 245 246 247 248 27 28 249 250 251 253 254 255 256 257 258
  169.   259 260 261 262 263 264 265 266 109 110 267 268 269 270 272 300
  170.   301 302 305 314 315 158 155 163 320 321 322 323 324 325 326 150
  171.   164 169 327 328 329 330 331 332 333 334 335 336 337 338 339 340
  172.   341 342 343 344 345 346
  173. .packtomark
  174.  
  175. ] readonly def
  176.  
  177. % ---------------- Font loading ---------------- %
  178.  
  179. % ------ Utilities ------ %
  180.  
  181. /advance {    % <n> advance -
  182.   f cff eq { pos add /pos exch store } { pop } ifelse
  183. } bind def
  184. /next {        % - next <byte>
  185.   f read {
  186.     1 advance
  187.     CFFDEBUG { (  ) print dup = } if
  188.   } {
  189.     0
  190.     CFFDEBUG { (  Out of range access, assuming 0) = } if
  191.     /pdfformaterror where {
  192.       pop 
  193.       (   **** Warning: Out of range access to a CFF table, assuming 0.\n)
  194.       pdfformaterror
  195.     } if
  196.   } ifelse
  197. } bind def
  198. /next2 {    % - next2 <byte1> <byte2>
  199.   f read {
  200.     f read {
  201.       2 advance
  202.       CFFDEBUG { (  ) print 1 index =only (,) print dup = } if
  203.     } {
  204.       1 advance
  205.       CFFDEBUG { (  ) print dup = } if
  206.     } ifelse
  207.   } if
  208. } bind def
  209. /nextstring {    % <length> nextstring <string>
  210.   dup 0 eq {
  211.     pop ()
  212.   } {
  213.     string f exch readstring pop dup length advance
  214.     CFFDEBUG { (  ) print dup == } if
  215.   } ifelse
  216. } bind def
  217. /card8        % - card8 <card8>
  218.  /next load
  219. def
  220. /card16 {    % - card16 <card16>
  221.   next2 exch 8 bitshift add
  222. } bind def
  223. /card32 {    % - card32 <card32>
  224.   card16 16 bitshift card16 add
  225. } bind def
  226. /offsetprocs [
  227.   /card8 load
  228.   /card16 load
  229.   { card8 16 bitshift card16 add } bind
  230.   /card32 load
  231. ] readonly def
  232. /offsetproc {    % <offsize> offsetproc <proc>
  233.   1 sub //offsetprocs exch get
  234. } bind def
  235. /offset {    % <offsize> offset <offset>
  236.   offsetproc exec
  237. } bind def
  238. /sid        % - <sid> sid
  239.   /card16 load
  240. def
  241. /Index {    % <name> Index <name> <array>
  242.   CFFDEBUG { (% reading Index: ) print dup = } if
  243.   mark card16
  244.   dup 0 ne {
  245.     1 exch next
  246.     dup 0 eq { 
  247.       pop       % skip incorrect index, bug 689854
  248.     } {
  249.       offsetproc dup exec pop exch {
  250.         dup exec dup 4 -1 roll sub 3 1 roll exch
  251.       } repeat
  252.     } ifelse pop
  253.   } if pop .packtomark
  254.   CFFDEBUG { (% Index lengths = ) print dup === } if
  255.   [ exch { nextstring } forall ] readonly
  256. } bind def
  257. /tokens {    % - tokens <num1> ... <op#> (op# = 12 means EOF)
  258.   {
  259.     f read not { 12 exit } if
  260.     CFFDEBUG { (..) print dup = } if
  261.     1 advance
  262.     dup 12 eq { pop next 32 add exit } if
  263.     dup 28 lt { exit } if
  264.     dup 32 lt {
  265.       28 sub {
  266.     { card16 32768 xor 32768 sub }
  267.     { 4 offset dup 16#7fffffff gt { -1 32 bitshift add } if }
  268.     { tokenreal }
  269.     { 31 exit }
  270.       } exch get exec
  271.     } {
  272.       dup 247 lt {
  273.     139 sub
  274.       } {
  275.     247 sub {
  276.       { next 108 add }
  277.       { next 364 add }
  278.       { next 620 add }
  279.       { next 876 add }
  280.       { next 108 add neg }
  281.       { next 364 add neg }
  282.       { next 620 add neg }
  283.       { next 876 add neg }
  284.       % 255 is deliberately omitted and will cause a rangecheck
  285.     } exch get exec
  286.       } ifelse
  287.     } ifelse
  288.   } loop
  289. } bind def
  290. /tokenbuf 100 string def
  291. /tokenput {    % <index> <str> tokenput <index+length>
  292.   dup length 3 1 roll
  293.   tokenbuf 2 index 3 -1 roll putinterval add
  294. } bind def
  295. /tokenrealarray [
  296.  (0)(1)(2)(3)(4)(5)(6)(7)(8)(9)(.)(E)
  297.  (E-)
  298.  ()        % ignore the invalid value
  299.  (-)
  300.  { exit } bind
  301. ] readonly def
  302. /tokenreal {    % - tokenreal <float>
  303.   0 {
  304.     next exch 1 index -4 bitshift tokenrealarray exch get exec tokenput
  305.         % We must leave the byte on the stack temporarily so that
  306.         % the exit will see a consistent stack state.
  307.     1 index 15 and tokenrealarray exch get exec tokenput exch pop
  308.   } loop
  309.   tokenbuf 0 3 -1 roll getinterval cvr exch pop
  310. } bind def
  311. /Dict {        % <opsdict> Dict -
  312.   /opdict exch store {
  313.     mark tokens
  314.     CFFDEBUG { (tokens: ) print ] dup === mark exch aload pop } if
  315.     opdict exch .knownget { exec } if cleartomark
  316.   } loop cleartomark
  317. } bind def
  318. /idstring {    % <sid> idstring <string|name>
  319.   dup 391 lt { //StandardStrings } { 391 sub strings } ifelse exch get
  320. } bind def
  321. /idname {    % <sid> idname <name>
  322.   idstring dup type /nametype ne { cvn } if
  323. } bind def
  324. /subfilefilter {    % <file> <length> subfilefilter <filter>
  325.     % SubFileDecode interprets a length of 0 as infinite.
  326.   dup 0 le { pop pop () 0 } if () /SubFileDecode filter
  327. } bind def
  328.  
  329. % ------ Top dictionary ------ %
  330.  
  331. /offput {    % <offset> <proc> offput -
  332.   1 index 0 le
  333.   CFFDEBUG { dup { (not ) print } if (queued: ) print 2 index =only ( ) print 1 index === } if
  334.   { pop pop
  335.   }
  336.   { currentdict exch aload length 1 add packedarray cvx
  337.       offsets 3 1 roll put
  338.   }
  339.   ifelse
  340. } bind def
  341. /queueput {    % <font> <proc> queueput -
  342.   16#7fffffff offsets { pop .min } forall
  343.   pos sub nextstring
  344.   3 1 roll aload length 2 add packedarray cvx
  345.   [ queued aload pop counttomark 2 add -1 roll ]
  346.   /queued exch store
  347. } bind def
  348. /printvk {    % <value> <key> printvk <value> <key>
  349.   CFFDEBUG { (\t% ) print dup =only ( = ) print 1 index === } if
  350. } bind def
  351. /xxput {    % <value> <key> <dict> xxput -
  352.   3 1 roll exch put
  353. } bind def
  354. /putfi {    % <value> <key> putfi -
  355.   printvk FontInfo xxput
  356. } bind def
  357. /xdef {        % <value> <key> xdef -
  358.   exch def
  359. } bind def
  360. /pxdef {    % <value> <key> pxdef -
  361.   printvk xdef
  362. } bind def
  363. /topdictops mark
  364.   12 { CFFDEBUG { (\t% EOD) = } if exit }
  365.   0 { idstring /version putfi }
  366.   1 { idstring /Notice putfi }
  367.   32 { idstring /Copyright putfi }
  368.   2 { idstring /FullName putfi }
  369.   3 { idstring /FamilyName putfi }
  370.   4 { idstring /Weight putfi }
  371.   33 { 0 ne /isFixedPitch putfi }
  372.   34 { /ItalicAngle putfi }
  373.   35 { /UnderlinePosition putfi }
  374.   36 { /UnderlineThickness putfi }
  375.   37 { /PaintType pxdef }
  376.   38 { /FontType pxdef }        % actually CharstringType
  377.   39 { counttomark array astore /FontMatrix pxdef }
  378.   13 { /UniqueID pxdef }
  379.   5 { counttomark array astore /FontBBox pxdef }
  380.   40 { /StrokeWidth pxdef }
  381.   14 { counttomark array astore /XUID pxdef }
  382.   15 {
  383.     /charset printvk pop
  384.     dup StandardCharsets length lt {
  385.       StandardCharsets exch get /charset xdef
  386.     } {
  387.       { queuecharset } offput
  388.     } ifelse
  389.   }
  390.   16 {
  391.     /Encoding printvk pop
  392.     dup StandardEncodings length lt {
  393.       /Encoding xdef
  394.     } {
  395.       { queueEncoding } offput
  396.     } ifelse
  397.   }
  398.   17 { { readCharStrings } offput }
  399.   18 { exch /readPrivate cvx 2 packedarray offput }
  400.     % CIDFont operators
  401.   62 {        % ROS, must be first in a CIDFont
  402.     currentdict /FontType undef
  403.     currentdict /Encoding undef
  404.     currentdict /FontMatrix undef
  405.     /CIDFontVersion 0 def
  406.     /CIDFontRevision 0 def
  407.     /CIDFontType 0 def
  408.     /CIDCount 8720 def % Default value defined in CFF spec.
  409.     3 dict begin
  410.     /Supplement pxdef
  411.     idstring dup type /nametype eq { .namestring } if /Ordering pxdef
  412.     idstring dup type /nametype eq { .namestring } if /Registry pxdef
  413.     /CIDSystemInfo currentdict end def
  414.   }
  415.   63 { /CIDFontVersion pxdef }
  416.   64 { /CIDFontRevision pxdef }
  417.   65 { /CIDFontType pxdef }
  418.   66 { /CIDCount pxdef }
  419.   67 { /UIDBase pxdef }
  420.   68 { { readFDArray } offput }
  421.   69 { { readFDSelect } offput }
  422.     % This operator only appears in a FDArray element.
  423.     % We don't really need it, so ignore an error.
  424.   70 { { idstring } .internalstopped { pop pop } { /FontName pxdef } ifelse }
  425. .dicttomark readonly def
  426.  
  427. % readcharset and readFDSelect may require the length of CharStringArray,
  428. % but these structures may occur in the file before the CharStrings.
  429. % If that happens, use a hack: assume that all the data up to the next
  430. % queued read should be read.
  431.  
  432. /charstringcount {    % <font> charstringcount <count> true
  433.             % <font> charstringcount <length> false
  434.   /CharStringArray .knownget {
  435.     length true
  436.   } {
  437.     % Hack: look for the next queued read.
  438.     16#7fffffff offsets { pop .min } forall
  439.     pos sub false
  440.   } ifelse
  441. } bind def
  442.  
  443. /readCharStrings {    % <font> readCharStrings -
  444.   /CharStringArray Index put
  445. } bind def
  446.  
  447. % ------ Charsets and encodings ------ %
  448.  
  449. % Note: formats 1 and 2 can overflow the operand stack.
  450. % We'll fix this if it ever becomes necessary.
  451. /charsetcount {
  452.   charstringcount { 1 sub } { 2 idiv } ifelse
  453. } bind def
  454. /charsetformats [
  455. { [ 0 3 -1 roll charsetcount { sid } repeat ]
  456. } bind
  457. { [ 0 3 -1 roll charsetcount {
  458.     dup 0 eq { pop exit } if
  459.     sid card8 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
  460.   } loop ]
  461. } bind
  462. { [ 0 3 -1 roll charsetcount {
  463.     dup 0 eq { pop exit } if
  464.     sid card16 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
  465.   } loop ]
  466. } bind
  467. ] readonly def
  468. /queuecharset {        % <font> queuecharset -
  469.   { readcharset } queueput
  470. } bind def
  471. /readcharset {        % <data> <font> readcharset -
  472.   begin 0 () /SubFileDecode filter /f exch store
  473.   charsetformats next get currentdict exch exec /charset exch def end
  474. } bind def
  475.  
  476. /encodingformats [
  477. { 1 1 next { next exch Encoding 3 1 roll put } for
  478. } bind
  479. { 1 next {
  480.     next next 1 add {
  481.             % Stack: gid code
  482.       Encoding 1 index 3 index put
  483.       exch 1 add exch 1 add
  484.     } repeat pop
  485.   } repeat pop
  486. } bind
  487. ] readonly def
  488. /queueEncoding {    % <font> queueEncoding -
  489.   { readEncoding } queueput
  490. } bind def
  491. /readEncoding {        % <data> <font> readEncoding -
  492.   begin 0 () /SubFileDecode filter /f exch store
  493.   /Encoding [ 256 { /.notdef } repeat ] def
  494.   next encodingformats 1 index 127 and get exec
  495.   128 ge {
  496.             % Read supplementary encodings.
  497.     next {
  498.       Encoding next sid idname put
  499.     } repeat
  500.   } if end
  501. } bind def
  502.  
  503. % ------ FDArray and FDSelect ------ %
  504.  
  505. /readFDArray {        % <font> readFDArray -
  506.   /FDarray Index exch pop exch
  507.   2 dict begin /f null def begin
  508.   [ exch {
  509.     dup length subfilefilter /f exch store
  510.     10 dict begin
  511.     /FontType 2 def
  512.     /PaintType 0 def
  513.     /FontMatrix [0.001 0 0 0.001 0 0] def
  514.     /Private 20 dict def
  515.     //topdictops Dict currentdict end
  516.   } forall ] /FDArray xdef end end
  517. } bind def
  518.  
  519. /fdselectformats [
  520. % Note: this procedure can overflow the operand stack.
  521. % We'll fix this if it ever becomes necessary.
  522. { [ exch charstringcount pop { card8 } repeat ] } bind    % Format 0
  523. { /FDSelect cvx /invalidfont signalerror } bind        % Format 1
  524. dup                            % Format 2
  525. % The following procedure does not use excessive op-stack space.
  526. { pop 65535 array card16 card16 exch            % Format 3
  527.   { % Stack: array previndex
  528.     card8 card16 
  529.     exch 1 index 4 -1 roll
  530.     exch 1 exch 1 sub
  531.     { 3 index exch 2 index put } for pop
  532.   } repeat
  533.   % now resize the array to the final index.
  534.   0 exch getinterval
  535. } bind
  536. ] readonly def
  537.  
  538. /readFDSelect {        % <font> readFDSelect -
  539.   begin fdselectformats next get currentdict exch exec /FDSelect exch def end
  540. } bind def
  541.  
  542.  
  543. % ------ Private dictionary ------ %
  544.  
  545. /deltarray {        % -mark- <num1> ... deltarray <num1'> ...
  546.   0 counttomark 1 sub { counttomark -1 roll add dup } repeat pop
  547.   counttomark array astore
  548. } bind def
  549.  
  550. /privatedictops mark
  551.   12 { CFFDEBUG { (\t% EOD) = } if exit }
  552.   6 { deltarray /BlueValues pxdef }
  553.   7 { deltarray /OtherBlues pxdef }
  554.   8 { deltarray /FamilyBlues pxdef }
  555.   9 { deltarray /FamilyOtherBlues pxdef }
  556.   41 { /BlueScale pxdef }
  557.   42 { /BlueShift pxdef }
  558.   43 { /BlueFuzz pxdef }
  559.   10 { 1 array astore /StdHW pxdef }
  560.   11 { 1 array astore /StdVW pxdef }
  561.   44 { deltarray /StemSnapH pxdef }
  562.   45 { deltarray /StemSnapV pxdef }
  563.   46 { 0 ne /ForceBold pxdef }
  564.   47 { /ForceBoldThreshold pxdef }
  565.   48 { /lenIV pxdef }
  566.   49 { /LanguageGroup pxdef }
  567.   50 { /ExpansionFactor pxdef }
  568.   51 { /initialRandomSeed pxdef }
  569.   19 { PrivateStart add { readSubrs } offput }
  570.   20 { /defaultWidthX pxdef }
  571.   21 { /nominalWidthX pxdef }
  572.     % Multiple Master fonts only
  573.   59 { /NDV pxdef }
  574.   60 { /CDV pxdef }
  575.   61 { /lenBuildCharArray pxdef }
  576. .dicttomark readonly def
  577.  
  578. /readPrivate {        % <font> <size> readPrivate -
  579.   2 dict begin
  580.   f 3 1 roll exch       % f <size> <font> 
  581.   StringCache queued_offset known {
  582.     /PrivateStart queued_offset def
  583.   } {
  584.     /PrivateStart pos def
  585.     1 index 0 gt {
  586.       f 2 index string readstring pop
  587.     } {
  588.       ()
  589.     } ifelse
  590.     StringCache queued_offset 2 index put
  591.     0 () /SubFileDecode filter
  592.     /f exch store
  593.   } ifelse
  594.   dup /FontType .knownget not { 2 } if exch
  595.   /Private get begin
  596.         % Default lenIV to -1 even for Type 1 CharStrings.
  597.   2 ne { /lenIV -1 def } if
  598.   //privatedictops Dict end
  599.   exch /f exch store advance
  600.   end
  601. } bind def
  602.  
  603. /readSubrs {        % <font> readSubrs -
  604.   /Subrs Index put
  605. } bind def
  606.  
  607. % ------ Main program ------ %
  608.  
  609. % Clean up after finishing a font.
  610. /cleanupFont {        % (currentdict) cleanupFont -
  611.         % Remove unwanted entries.
  612.   currentdict /charset undef
  613.   currentdict /CharStringArray undef
  614. } bind def
  615.  
  616. % Update the Encoding and CharStrings for a real font.
  617. /finishFont {        % (currentdict) finishFont -
  618.         % Construct the real Encoding.
  619.         % The value of Encoding is either a number, for predefined
  620.         % encodings, or an array of mixed GIDs and names.
  621.   /Encoding mark Encoding
  622.   CFFDEBUG { (Encoding: ) print dup === flush } if
  623.   dup type /integertype eq {
  624.     StandardEncodings exch get { idname } forall
  625.   } {
  626.     {
  627.       dup type /integertype eq { charset exch get idname } if
  628.     } forall
  629.   } ifelse .packtomark def
  630.         % Construct the CharStrings.
  631.         % Note that they may only correspond to an initial
  632.         % subset of the charset.
  633.   /CharStrings charset length CharStringArray length .min dict def
  634.   CFFDEBUG {
  635.     charset length =only ( charset ) print
  636.     CharStringArray length =only ( CharStringArray) =
  637.     charset == flush
  638.   } if
  639.   0 1 CharStrings maxlength 1 sub {
  640.     dup CharStringArray exch get
  641.     exch charset exch get idstring CharStrings xxput
  642.   } for
  643.   cleanupFont
  644. } bind def
  645.  
  646. % Replace CharStrings with GlyphDirectory for a CIDFont;
  647. % Move GlobalSubrs to descendent fonts.
  648. /finishCIDFont {    % (currentdict) finishCIDFont -
  649.         % Construct the GlyphDirectory, similar to CharStrings.
  650.   /FDBytes FDArray length 1 gt { 1 } { 0 } ifelse def
  651.   /GlyphDirectory charset length CharStringArray length .min dict def
  652.   CFFDEBUG {
  653.     charset length =only ( charset ) print
  654.     CharStringArray length =only ( CharStringArray) =
  655.     charset == flush
  656.   } if
  657.   0 1 GlyphDirectory maxlength 1 sub {
  658.     dup CharStringArray exch get
  659.         % If there is more than one FDArray entry, add the font
  660.         % index to the beginning of each charstring.
  661.     FDBytes 1 eq {
  662.       FDSelect 2 index get
  663.       1 string dup 0 4 -1 roll put exch concatstrings
  664.     } if
  665.     exch charset exch get GlyphDirectory xxput
  666.   } for
  667.  
  668.   Private /GlobalSubrs .knownget {
  669.     FDArray {
  670.     /Private get /GlobalSubrs 2 index put
  671.     } forall
  672.     pop
  673.     Private /GlobalSubrs undef
  674.   } if
  675.  
  676.         % Clean up.
  677.   currentdict /FDSelect undef
  678.   cleanupFont
  679. } bind def
  680.  
  681. % PDF may load OpenType font containing ordinary CFF data as a CIDFont.
  682. % Convert the ordinary font to a CIDFont.
  683. /makeCIDFont {        % (currentdict) finishCIDFont -
  684.   /CIDFontType 0 def
  685.   /FDBytes 0 def
  686.   /GDBytes 0 def
  687.   /CIDMapOffset 0 def
  688.  
  689.   /CIDSystemInfo 3 dict begin  % bogus
  690.     /Registry   (Adobe) def
  691.     /Ordering   (Identity) def
  692.     /Supplement 0 def
  693.   currentdict end def
  694.  
  695.   /FDArray 4 dict begin
  696.     /FontMatrix dup load { 1000 0 0 1000 0 0 } matrix concatmatrix def
  697.     /Private    dup load def
  698.     /FontType   dup load def
  699.     /PaintType  dup load def
  700.   currentdict end 1 array astore def
  701.  
  702.   /FontType 9 def
  703.  
  704.   /GlyphDirectory CharStringArray def
  705.   /CIDCount GlyphDirectory length def
  706.  
  707.   currentdict /Private undef
  708.   currentdict /Encoding undef
  709.   currentdict /CharStrings undef
  710.   currentdict /UniqueID undef
  711.   currentdict /XUID undef
  712.   cleanupFont
  713. } bind def
  714.  
  715. % We need to pass the file as a parameter for the sake of the PDF
  716. % interpreter. Also for the sake of PDF, a flag forces the font
  717. % to be defined as <resname> instead of the name embedded in the data.
  718. % This is needed for subsetted fonts; it is valid if the CFF
  719. % contains only a single font.
  720. % Finally, PDF interpreter may request creation of CIDFont out of an
  721. % ordinary CFF font.
  722. /StartData {          % <resname> <nbytes> StartData -
  723.   currentfile exch subfilefilter //false //false ReadData pop
  724. } bind def
  725. /ReadData {           % <resname> <file> <forceresname> <forcecid> ReadData <fontset>
  726.     % Initialize.
  727.  
  728.   30 dict begin
  729.   /forcecidfont exch def
  730.   /forceresname exch def
  731.   /cff exch def
  732.   /pos 0 def
  733.   /resname exch cvlit def
  734.   /DEBUG CFFDEBUG def    % bring the binding closer
  735.   /StringCache 1 dict def % Private DICT may be reused.
  736.  
  737.     % Read the header.
  738.  
  739.   /f cff def
  740.   /vmajor next def
  741.   /vminor next def
  742.   /hdrsize next def
  743.   /aoffsize next def
  744.   hdrsize 4 gt {
  745.     hdrsize 4 sub dup advance
  746.     f exch () /SubFileDecode filter flushfile
  747.   } if
  748.  
  749.     % Read the Indexes.
  750.  
  751.   /names Index def
  752.   /topdicts Index def
  753.   /strings Index def
  754.   /gsubrs Index def
  755.  
  756.     % Read the top Dicts.
  757.  
  758.   /offsets 50 dict def
  759.   /queued [] def
  760.   /opdict null def        % reserve a slot
  761.   /fonts [ topdicts {
  762.     0 () /SubFileDecode filter /f exch def
  763.     40 dict begin
  764.         % Preload defaults that differ from PostScript defaults,
  765.         % or that are required.
  766.       /FontType 2 def
  767.       /PaintType 0 def
  768.       /FontMatrix [0.001 0 0 0.001 0 0] def
  769.       /charset StandardCharsets 0 get def
  770.       /Encoding 0 def
  771.       /FontInfo 10 dict
  772.     dup /UnderlinePosition -100 put
  773.     dup /UnderlineThickness 50 put
  774.       def
  775.       /Private 20 dict
  776.     gsubrs length 0 ne { dup /GlobalSubrs gsubrs put } if
  777.       def
  778.       //topdictops Dict
  779.     currentdict end
  780.   } forall ] def
  781.  
  782.     % Read other tables with queued offsets.
  783.         % We process these in order so we can advance if needed.
  784.     % The CFF file may not be positionable.
  785.   {        % outer loop since offsets may be updated when processing
  786.     CFFDEBUG { (offsets: ) print [ offsets { pop } forall ] == } if
  787.     [ offsets { pop } forall ] { lt } .sort    % process in order of appearance
  788.     { 
  789.       CFFDEBUG { (queued offset: ) print dup =print flush (, current pos=) print pos = } if
  790.       /queued_offset 1 index def
  791.       StringCache 1 index .knownget {
  792.         /f exch 0 () /SubFileDecode filter def
  793.       } {
  794.         /f cff def
  795.         dup pos ne { dup pos sub nextstring pop } if    % negative advance will cause error
  796.       } ifelse
  797.       offsets exch 2 copy get 3 1 roll undef
  798.       CFFDEBUG { (exec queued: ) print dup == } if
  799.       exec
  800.     } forall
  801.     offsets length 0 eq { exit } if
  802.   } loop
  803.  
  804.     % Process out-of-order tables.
  805.  
  806.   CFFDEBUG { queued length =only ( queued) = flush } if
  807.   queued { exec } forall
  808.  
  809.     % Update Encoding and CharStrings.
  810.  
  811.   fonts {
  812.     begin
  813.     currentdict /CIDFontType known {
  814.       finishCIDFont
  815.     } {
  816.       forcecidfont //makeCIDFont //finishFont ifelse
  817.     } ifelse
  818.     end
  819.   } forall
  820.  
  821.     % Wrap up.
  822.  
  823.   resname mark 0 1 fonts length 1 sub {
  824.     CFFDEBUG { dup =only ( ) print flush } if
  825.     dup names exch get
  826.     forceresname { pop resname } if
  827.     CFFDEBUG { dup == flush } if
  828.     exch fonts exch get
  829.     dup /CIDFontType known {
  830.         % This is a CIDFont.
  831.       dup /CIDFontName 3 index put
  832.       1 index exch /CIDFont defineresource
  833.     } {
  834.         % This is a font.
  835.       dup /FontName 3 index put
  836.       1 index exch definefont
  837.     } ifelse
  838.   } for .dicttomark
  839.   end        % temporary dict
  840.   end        % FontSetInit ProcSet
  841.   /FontSet defineresource
  842.  
  843. } bind def
  844.  
  845. % ---------------- Resource category definition ---------------- %
  846.  
  847. currentdict end readonly
  848.  
  849. languagelevel exch 2 .setlanguagelevel
  850.  
  851. /FontSet /Generic /Category findresource dup length dict .copydict
  852. /Category defineresource pop
  853.  
  854. /FontSetInit exch /ProcSet defineresource pop
  855.  
  856. .setlanguagelevel
  857.